package com.lyf.language.practice.practice_6_21.collection;

import io.netty.util.internal.ConcurrentSet;
import net.sf.cglib.beans.FixedKeySet;
import org.junit.Test;

import java.util.*;
import java.util.concurrent.*;

/**
 * 集合框架
 * 1.Iterator/Iterable
 * 2.Set,Map,List,
 * 3.基础操作
 * List的基本API和具体实现的API
 *
 * @author LYF
 * @date 2022/6/22
 */
public class CollectionTests {
    /**
     * List：
     * ArrayList,LinkedList
     * 及对比数组的区别
     *
     * 基本概念：
     *
     *
     *
     * 集合的分析角度：
     * 一、概念
     * 1.线性表、集合、映射
     * 基本概念，是做什么的，什么样的逻辑结构、物理结构
     * 例：线性表，存储线性关系的集合，可重复，有序性排列 ，二维表存储，数据库查询出来的用户表rs等
     * 集合，无序，去重
     * 映射/hash：k-v，键值对，无序，索引问题，查找等
     *
     * 二、详细
     * 1.层级结构 --→  分析源码、JDK的设计思想，OOP思想，继承拓展关系等、、、复用
     * 2.底层结构（属性） -- 基本是存储方面的特性；对于数组类需要考虑默认容量、扩容机制等；
     * 数组：
     * 链表：
     *
     * IAAS（设施即服务，，存储+计算+通信 -- 基础的Java程序  涉及的通信则是函数调用，无需关心
     *
     * 3.基本API和实现（方法、表现）、特性分析（时空复杂度、优缺点-可结合属性谈） -- 基本上是计算方面的熟悉，需要考虑
     * 线程安全性（并发操作、单用户操作），操作特性，
     *
     *
     * 4.场景应用、对比，如何有效正确使用（为什么？，来源1-3和实战分析、经验）
     * 5.其他对比、联系、理解（拓展、提升、创新、造轮子）
     * 聊发展、聊历史（JDK哪个版本推出的....）
     *
     *
     */
    @Test
    public void testList(){
        List<Integer> list1 = new ArrayList<>();// Object[]-数组 扩容 1.5 默认10
        /**
         1.层级关系：LinkedList<E>
         extends AbstractSequentialList<E>
         implements List<E>, Deque<E>, Cloneable, java.io.Serializable
         2.底层结构(--即看 属性--属性决定组成、状态  )：
         “transient关键字只能修饰变量,而不能修饰方法和类。 一旦变量被transient修饰,
         变量将不再是对象持久化的一部分,该变量内容在序列化后无法获得访问
         transient Node<E> first;
         （静态内部类 private static class Node{ E item;
         Node<E> next;
         Node<E> prev;}）
         transient LinkedList.Node<E> last;

         3.基本API（--行为、方法） ---    需要 考虑 并发操作、线程安全性；基本CRUD情况特性

         4.由属性决定 API 的特性与操作 →  特性（从操作、行为的逻辑--CRUD，时空复杂度  出发）
         */
        List<Integer> list2 = new LinkedList<>();//
        /**
         1.层级关系
         public class CopyOnWriteArrayList<E>
         implements List<E>, RandomAccess, Cloneable, java.io.Serializable
         private static final long serialVersionUID = 8673264195747942595L
         * The lock protecting all mutators.  (We have a mild preference
         * for builtin monitors over ReentrantLock when either will do.)

         final transient Object lock = new Object(); → 抢锁---线程安全，并发
         private transient volatile Object[] array;

         // 通过 Ctrl + F 搜索 synchronized 查询 需要加锁的方法
         --add，remove, sort, ..
         public E set(int index, E element) {
         synchronized (lock) {
         Object[] es = getArray();
         E oldValue = elementAt(es, index);

         if (oldValue != element) {
         es = es.clone();
         es[index] = element;
         }
         // Ensure volatile write semantics even when oldvalue == element
         setArray(es);
         return oldValue;
         }
         }

         2.底层结构（数组）

         3.基本API，add，remove

         4.场景应用--（并发场景

         */
        List<Integer> list3 = new CopyOnWriteArrayList<>();

        /**
         1.层级结构

         Vector<E>
         extends AbstractList<E>
         implements List<E>, RandomAccess, Cloneable, java.io.Serializable

         2.底层存储
         protected Object[] elementData;

         protected int elementCount;

         * The amount by which the capacity of the vector is automatically
         * incremented when its size becomes greater than its capacity.  If
         * the capacity increment is less than or equal to zero, the capacity
         * of the vector is doubled each time it needs to grow.
         protected int capacityIncrement;

         默认容量--
         public Vector() {
         this(10);
         }
         扩容机制
         private Object[] grow() {
         return grow(elementCount + 1);
         }

         --直接在方法上面加锁--

         */
        List<Integer> list4 = new Vector<>();


        /**
         1.层级关系

         class Stack<E> extends Vector<E>

         public E push(E item) {
         addElement(item);

         return item;
         }

         拓展：
         push、pop、peek等

         */
        List<Integer> list5 = new Stack<>();
    }

    /**


     */
    @Test
    public void testMap(){
        /**
         1.层级关系

         2.存储结构
         扩容机制：
         newThr = oldThr << 1; // double threshold

         3.基本API

         4.场景应用


         */
        Map<String,String> map1 = new HashMap<>();
        Map<String,String> map2 = new LinkedHashMap<>();
        Map<String,String> map3 = new TreeMap<>();
        Map<String,String> map4 = new Hashtable<>();
        Map<String,String> map5 = new IdentityHashMap<>();
        Map<String,String> map6 = new WeakHashMap<>();
        Map<String,String> map7 = new ConcurrentSkipListMap<>();
        Map<String,String> map8 = new ConcurrentHashMap<>();




    }


    /**



     */
    @Test
    public void testSet(){

        /*
        1.层级结构
        public class HashSet<E>
        extends AbstractSet<E>
        implements Set<E>, Cloneable, java.io.Serializable

        2.底层结构
       private transient HashMap<E,Object> map;

       // Dummy value to associate with an Object in the backing Map
       private static final Object PRESENT = new Object();

     * Constructs a new, empty set; the backing {@code HashMap} instance has
     * default initial capacity (16) and load factor (0.75).
    public HashSet() {
            map = new HashMap<>();
        }


        */
        Set<Integer> set1 = new HashSet<>();
        /**
         1.层级结构
         public class LinkedHashSet<E>
         extends HashSet<E>
         implements Set<E>, Cloneable, java.io.Serializable

         */
        Set<Integer> set2 = new LinkedHashSet<>();
        Set<Integer> set3 = new TreeSet<>();
        Set<Integer> set4 = new CopyOnWriteArraySet<>();
        /*
        TODO -- 学习跳表

         * Head nodes          Index nodes
         * +-+    right        +-+                      +-+
         * |2|---------------->| |--------------------->| |->null
         * +-+                 +-+                      +-+
         *  | down              |                        |
         *  v                   v                        v
         * +-+            +-+  +-+       +-+            +-+       +-+
         * |1|----------->| |->| |------>| |----------->| |------>| |->null
         * +-+            +-+  +-+       +-+            +-+       +-+
         *  v              |    |         |              |         |
         * Nodes  next     v    v         v              v         v
         * +-+  +-+  +-+  +-+  +-+  +-+  +-+  +-+  +-+  +-+  +-+  +-+
         * | |->|A|->|B|->|C|->|D|->|E|->|F|->|G|->|H|->|I|->|J|->|K|->null
         * +-+  +-+  +-+  +-+  +-+  +-+  +-+  +-+  +-+  +-+  +-+  +-+

         * Notation guide for local variables
         * Node:         b, n, f, p for  predecessor, node, successor, aux
         * Index:        q, r, d    for index node, right, down.
         * Head:         h
         * Keys:         k, key
         * Values:       v, value
         * Comparisons:  c

         */
        Set<Integer> set5 = new ConcurrentSkipListSet<>();// 跳表实现

        Set<Integer> set6 = new ConcurrentSet<>();
        Set<Integer> set7 = new FixedKeySet(new String[]{"1","2"});


    }







}
